use std::fs::File;
use std::io;
use std::io::{BufReader, Read};
use crate::lipo_info;
use crate::ltools::{lfile, lstring, ltime};


// 成功
const LICENSE_VER_SUCCESS:u32 = 0;
// 找不到license 文件
const LICENSE_VER_NO_FILE:u32 = 2;
// 读取文件失败
const LICENSE_VER_READ_ERROR:u32 = 3;
// license 非法APPid
const LICENSE_VER_APPID_ERROR:u32 = 4;
// license 过期
const LICENSE_VER_EXPIRE_ERROR:u32 = 5;



/* 校验license 返回不同的结果值 */
pub(crate) fn verfiy_license(path: &str) -> u32 {
    match File::open(path) {
        Ok(open_file) => {
            let mut reader = BufReader::new(open_file);

            let mut byte_vec: Vec<u8> = Vec::new();
            let mut byte_vec1: Vec<u8> = Vec::new();
            let mut byte_vec2: Vec<u8> = Vec::new();
            let mut byte_vec3: Vec<u8> = Vec::new();
            let mut lines = 1;

            for res in reader.bytes() {
                match res {
                    Ok(byte1) => {
                        if byte1 == b'\n' {
                            if byte_vec.len() > 0 {
                                let content = lstring::vec_string(&mut byte_vec);
                                // lexpose::print_info_log(content);
                                // 校验其中的数据值
                                let back = verfiy_content(lines, content.as_str());
                                if back != 0 {
                                    return back;
                                }

                                byte_vec.clear();
                            }
                            lines += 1;
                        } else {
                            match lines {
                                (0..=31) => {
                                    byte_vec.push(byte1);
                                }
                                32 => {
                                    byte_vec1.push(byte1);
                                }
                                32 => {
                                    byte_vec2.push(byte1);
                                }
                                34 => {
                                    byte_vec3.push(byte1);
                                }
                                _ => {}
                            }
                        }
                    }
                    Err(_) => {
                        // 读取文件失败
                        return LICENSE_VER_READ_ERROR;
                    }
                }
            }
            // 校验 加密 是否合规

            LICENSE_VER_SUCCESS
        }
        Err(_) => {
            // 找不到license文件
            return LICENSE_VER_NO_FILE;
        }
    }
}

pub(crate) fn verfiy_content(line: i32, content: &str) -> u32 {
    match line {
        1 => {
            if !content.eq("[Licensee]") {
                // 文件格式不对
                return LICENSE_VER_READ_ERROR;
            }
        }
        3 => {
            lipo_info!(format!("content: {}",content));
            if !content.eq("AppID=com.citc.rcs.full") {
                // appId 非法
                return LICENSE_VER_APPID_ERROR;
            }
        }
        4 => {
            let back = verfiy_license_time(content);
            if back !=0 {
                return back;
            }
        }
        _ => {}
    }

    0
}


pub(crate) fn verfiy_license_time(content: &str) -> u32 {
    if !content.starts_with("ExpirationDate=") {
        return LICENSE_VER_READ_ERROR;
    }

    if let Some(time_str) = ltime::jx_license_time(&content[15..]) {
        let license_time = ltime::str_to_date(time_str.as_str());
        let now_time = ltime::get_date_time();
        if now_time.gt(&license_time){
            // license 过期了
            return LICENSE_VER_EXPIRE_ERROR;
        }

        0
    } else {

        // 文件格式不对
        return LICENSE_VER_READ_ERROR;
    }


}










